home *** CD-ROM | disk | FTP | other *** search
/ IRIX 6.2 Applications 1996 May / SGI IRIX 6.2 Applications 1996 May.iso / dist / impr_dev.idb / usr / impressario / src / libimp / impRowMath.c.z / impRowMath.c
Encoding:
C/C++ Source or Header  |  1996-05-07  |  13.3 KB  |  582 lines
  1. /**************************************************************************
  2.  *
  3.  *           Copyright (c)    1993 Silicon Graphics, Inc.
  4.  *            All Rights Reserved
  5.  *
  6.  *       THIS    IS UNPUBLISHED PROPRIETARY SOURCE CODE OF SGI
  7.  *
  8.  * The copyright notice above does not evidence any actual of intended
  9.  * publication of such source code, and is an unpublished work by Silicon
  10.  * Graphics, Inc. This material contains CONFIDENTIAL INFORMATION that is
  11.  * the property of Silicon Graphics, Inc. Any use, duplication or
  12.  * disclosure not specifically authorized by Silicon Graphics is strictly
  13.  * prohibited.
  14.  *
  15.  * RESTRICTED RIGHTS LEGEND:
  16.  *
  17.  * Use, duplication or disclosure by the Government is subject to
  18.  * restrictions as set forth in subdivision (c)(1)(ii) of the Rights in
  19.  * Technical Data and Computer Software clause at DFARS 52.227-7013,
  20.  * and/or in similar or successor clauses in the FAR, DOD or NASA FAR
  21.  * Supplement. Unpublished - rights reserved under the Copyright Laws of
  22.  * the United States. Contractor is SILICON GRAPHICS, INC., 2011 N.
  23.  * Shoreline Blvd., Mountain View, CA 94039-7311
  24.  **************************************************************************
  25.  *
  26.  * File: impRowMath.c
  27.  *
  28.  * Description: Perform mathmatical operations on image rows.
  29.  *
  30.  **************************************************************************/
  31.  
  32.  
  33. #ident "$Revision: 1.2 $"
  34.  
  35.  
  36. #include <stdio.h>
  37. #include <bstring.h>
  38. #include <assert.h>
  39. #include "impI.h"
  40.  
  41.  
  42. /**************************************************************************
  43.  *
  44.  * Function: impZeroRow
  45.  *
  46.  * Description: Initializes a row of pixels to 0.
  47.  *
  48.  * Parameters: 
  49.  *    dptr (I) - row to zero
  50.  *    n (I) - number of pixels in row
  51.  *
  52.  * Return: none
  53.  *
  54.  **************************************************************************/
  55.  
  56. void impZeroRow(short *dptr, int n)
  57. {
  58.     /*
  59.      * Sanity check the inputs
  60.      */
  61.     assert(dptr != NULL);
  62.  
  63.     bzero(dptr, n * sizeof(short));
  64. }
  65.  
  66.  
  67. /**************************************************************************
  68.  *
  69.  * Function: impInitRow
  70.  *
  71.  * Description: Initializes a row of pixels to the specified value.
  72.  *
  73.  * Parameters: 
  74.  *    dptr (I) - row to initialize
  75.  *    val (I) - value to initialize row
  76.  *    n (I) - number of pixels in row
  77.  *
  78.  * Return: none
  79.  *
  80.  **************************************************************************/
  81.  
  82. void impInitRow(register short *dptr, register int val, register int n)
  83. {
  84.     /*
  85.      * Sanity check the inputs
  86.      */
  87.     assert(dptr != NULL);
  88.  
  89.     if (val == 0)
  90.     impZeroRow(dptr, n);
  91.     else {
  92.     while (n >= 8) {
  93.         dptr[0] = (short)val;
  94.         dptr[1] = (short)val;
  95.         dptr[2] = (short)val;
  96.         dptr[3] = (short)val;
  97.         dptr[4] = (short)val;
  98.         dptr[5] = (short)val;
  99.         dptr[6] = (short)val;
  100.         dptr[7] = (short)val;
  101.         dptr += 8;
  102.         n -= 8;
  103.     }
  104.     while (n--)
  105.         *dptr++ = (short)val;
  106.     }
  107. }
  108.  
  109.  
  110. /**************************************************************************
  111.  *
  112.  * Function: impCopyRow
  113.  *
  114.  * Description: Copies a row of pixels from source to desitination.
  115.  *    Source and destination can be the same.
  116.  *
  117.  *    destination = source
  118.  *
  119.  * Parameters: 
  120.  *    dptr (O) - destination row
  121.  *    sptr (I) - source row
  122.  *    n (I) - number of pixels in row
  123.  *
  124.  * Return: none
  125.  *
  126.  **************************************************************************/
  127.  
  128. void impCopyRow(short *dptr, short *sptr, int n)
  129. {
  130.     /*
  131.      * Sanity check the inputs
  132.      */
  133.     assert(dptr != NULL);
  134.     assert(sptr != NULL);
  135.  
  136.     /*
  137.      * If dptr == sptr we can optimize the processing
  138.      */
  139.     if (sptr == dptr)
  140.     return;
  141.  
  142.     bcopy(sptr, dptr, n * sizeof(short));
  143. }
  144.  
  145.  
  146. /**************************************************************************
  147.  *
  148.  * Function: impSAddRow
  149.  *
  150.  * Description: Performs scalar addition on the specified source row. The
  151.  *    scalar value is added to the source row and the result is
  152.  *    placed in the destination row. The source and destination rows
  153.  *    can be the same.
  154.  *
  155.  *    destination = source + value
  156.  *
  157.  * Parameters: 
  158.  *    dptr (O) - destination row
  159.  *    sptr (I) - source row
  160.  *    val (I) - value to add to the source row
  161.  *    n (I) - number of pixels in row
  162.  *
  163.  * Return: none
  164.  *
  165.  **************************************************************************/
  166.  
  167. void impSAddRow(register short *dptr, register short *sptr,
  168.                 register int val, register int n)
  169. {
  170.     /*
  171.      * Sanity check the inputs
  172.      */
  173.     assert(dptr != NULL);
  174.     assert(sptr != NULL);
  175.  
  176.     /*
  177.      * If dptr == sptr we can optimize the processing
  178.      */
  179.     if (sptr == dptr) {
  180.     while (n >= 8) {
  181.         dptr[0] += val;
  182.         dptr[1] += val;
  183.         dptr[2] += val;
  184.         dptr[3] += val;
  185.         dptr[4] += val;
  186.         dptr[5] += val;
  187.         dptr[6] += val;
  188.         dptr[7] += val;
  189.         dptr += 8;
  190.         n -= 8;
  191.     }
  192.     while (n--) {
  193.         *dptr = (*dptr) + val;
  194.         dptr++;
  195.     }
  196.     } else {
  197.     while (n >= 8) {
  198.         dptr[0] = sptr[0] + val;
  199.         dptr[1] = sptr[1] + val;
  200.         dptr[2] = sptr[2] + val;
  201.         dptr[3] = sptr[3] + val;
  202.         dptr[4] = sptr[4] + val;
  203.         dptr[5] = sptr[5] + val;
  204.         dptr[6] = sptr[6] + val;
  205.         dptr[7] = sptr[7] + val;
  206.         dptr += 8;
  207.         sptr += 8;
  208.         n -= 8;
  209.     }
  210.     while (n--)
  211.         *dptr++ = (*sptr++) + val;
  212.     }
  213. }
  214.  
  215.  
  216. /**************************************************************************
  217.  *
  218.  * Function: impVAddRow
  219.  *
  220.  * Description: Performs vector addition of the specified source rows
  221.  *    placing the result in the destination row.
  222.  *
  223.  *    destination = source1 + source2
  224.  *
  225.  * Parameters: 
  226.  *    dptr (O) - destination row
  227.  *    sptr1 (I) - source row 1
  228.  *    sptr2 (I) - source row 2
  229.  *    n (I) - number of pixels in row
  230.  *
  231.  * Return: none
  232.  *
  233.  **************************************************************************/
  234.  
  235. void impVAddRow(register short *dptr, register short *sptr1, 
  236.         register short *sptr2, register int n)
  237. {
  238.     /*
  239.      * Sanity check the inputs
  240.      */
  241.     assert(dptr != NULL);
  242.     assert(sptr1 != NULL);
  243.     assert(sptr2 != NULL);
  244.  
  245.     while (n >= 8) {
  246.     dptr[0] = sptr1[0] + sptr2[0];
  247.     dptr[1] = sptr1[1] + sptr2[1];
  248.     dptr[2] = sptr1[2] + sptr2[2];
  249.     dptr[3] = sptr1[3] + sptr2[3];
  250.     dptr[4] = sptr1[4] + sptr2[4];
  251.     dptr[5] = sptr1[5] + sptr2[5];
  252.     dptr[6] = sptr1[6] + sptr2[6];
  253.     dptr[7] = sptr1[7] + sptr2[7];
  254.     dptr += 8;
  255.     sptr1 += 8;
  256.     sptr2 += 8;
  257.     n -= 8;
  258.     }
  259.     while (n--) {
  260.     *dptr = (*sptr1) + (*sptr2);
  261.     sptr1++;
  262.     sptr2++;
  263.     dptr++;
  264.     }
  265. }
  266.  
  267.  
  268. /**************************************************************************
  269.  *
  270.  * Function: impSSubRow
  271.  *
  272.  * Description: Performs scalar subtraction on the specified source row. The
  273.  *    scalar value is subtracted from the source row and the result is
  274.  *    placed in the destination row. The source and destination rows
  275.  *    can be the same.
  276.  *
  277.  *    destination = source - value
  278.  *
  279.  * Parameters: 
  280.  *    dptr (O) - destination row
  281.  *    sptr (I) - source row
  282.  *    val (I) - value to subtracted from the source row
  283.  *    n (I) - number of pixels in row
  284.  *
  285.  * Return: none
  286.  *
  287.  **************************************************************************/
  288.  
  289. void impSSubRow(register short *dptr, register short *sptr,
  290.                 register int val, register int n)
  291. {
  292.     /*
  293.      * Sanity check the inputs
  294.      */
  295.     assert(dptr != NULL);
  296.     assert(sptr != NULL);
  297.  
  298.     /*
  299.      * If dptr == sptr we can optimize the processing
  300.      */
  301.     if (sptr == dptr) {
  302.     while (n >= 8) {
  303.         dptr[0] -= val;
  304.         dptr[1] -= val;
  305.         dptr[2] -= val;
  306.         dptr[3] -= val;
  307.         dptr[4] -= val;
  308.         dptr[5] -= val;
  309.         dptr[6] -= val;
  310.         dptr[7] -= val;
  311.         dptr += 8;
  312.         n -= 8;
  313.     }
  314.     while (n--) {
  315.         *dptr = (*dptr) - val;
  316.         dptr++;
  317.     }
  318.     } else {
  319.     while (n >= 8) {
  320.         dptr[0] = sptr[0] - val;
  321.         dptr[1] = sptr[1] - val;
  322.         dptr[2] = sptr[2] - val;
  323.         dptr[3] = sptr[3] - val;
  324.         dptr[4] = sptr[4] - val;
  325.         dptr[5] = sptr[5] - val;
  326.         dptr[6] = sptr[6] - val;
  327.         dptr[7] = sptr[7] - val;
  328.         dptr += 8;
  329.         sptr += 8;
  330.         n -= 8;
  331.     }
  332.     while (n--)
  333.         *dptr++ = (*sptr++) - val;
  334.     }
  335. }
  336.  
  337.  
  338. /**************************************************************************
  339.  *
  340.  * Function: impVSubRow
  341.  *
  342.  * Description: Performs vector subtraction of the specified source rows
  343.  *    placing the result in the destination row.
  344.  *
  345.  *    destination = source1 - source2
  346.  *
  347.  * Parameters: 
  348.  *    dptr (O) - destination row
  349.  *    sptr1 (I) - source row 1
  350.  *    sptr2 (I) - source row 2
  351.  *    n (I) - number of pixels in row
  352.  *
  353.  * Return: none
  354.  *
  355.  **************************************************************************/
  356.  
  357. void impVSubRow(register short *dptr, register short *sptr1,
  358.         register short *sptr2, register int n)
  359. {
  360.     /*
  361.      * Sanity check the inputs
  362.      */
  363.     assert(dptr != NULL);
  364.     assert(sptr1 != NULL);
  365.     assert(sptr2 != NULL);
  366.  
  367.     while (n >= 8) {
  368.     dptr[0] = sptr1[0] - sptr2[0];
  369.     dptr[1] = sptr1[1] - sptr2[1];
  370.     dptr[2] = sptr1[2] - sptr2[2];
  371.     dptr[3] = sptr1[3] - sptr2[3];
  372.     dptr[4] = sptr1[4] - sptr2[4];
  373.     dptr[5] = sptr1[5] - sptr2[5];
  374.     dptr[6] = sptr1[6] - sptr2[6];
  375.     dptr[7] = sptr1[7] - sptr2[7];
  376.     dptr += 8;
  377.     sptr1 += 8;
  378.     sptr2 += 8;
  379.     n -= 8;
  380.     }
  381.     while (n--) {
  382.     *dptr = (*sptr1) - (*sptr2);
  383.     sptr1++;
  384.     sptr2++;
  385.     dptr++;
  386.     }
  387. }
  388.  
  389.  
  390. /**************************************************************************
  391.  *
  392.  * Function: impSMulRow
  393.  *
  394.  * Description: Performs scalar multiplication on the specified source row.
  395.  *    The source row is multiplied by the specified constant and the
  396.  *    result is placed in the destination row. The source and destination
  397.  *    rows can be the same.
  398.  *
  399.  *    destination = source * value
  400.  *
  401.  * Parameters: 
  402.  *    dptr (O) - destination row
  403.  *    sptr (I) - source row
  404.  *    val (I) - value to multiply the source row
  405.  *    n (I) - number of pixels in row
  406.  *
  407.  * Return: none
  408.  *
  409.  **************************************************************************/
  410.  
  411. void impSMulRow(register short *dptr, register short *sptr,
  412.                 register int val, register int n)
  413. {
  414.     /*
  415.      * Sanity check the inputs
  416.      */
  417.     assert(dptr != NULL);
  418.     assert(sptr != NULL);
  419.  
  420.     /*
  421.      * If dptr == sptr we can optimize the processing
  422.      */
  423.     if (sptr == dptr) {
  424.     while (n >= 8) {
  425.         dptr[0] *= val;
  426.         dptr[1] *= val;
  427.         dptr[2] *= val;
  428.         dptr[3] *= val;
  429.         dptr[4] *= val;
  430.         dptr[5] *= val;
  431.         dptr[6] *= val;
  432.         dptr[7] *= val;
  433.         dptr += 8;
  434.         n -= 8;
  435.     }
  436.     while (n--) {
  437.         *dptr = (*dptr) * val;
  438.         dptr++;
  439.     }
  440.     } else {
  441.     while (n >= 8) {
  442.         dptr[0] = sptr[0] * val;
  443.         dptr[1] = sptr[1] * val;
  444.         dptr[2] = sptr[2] * val;
  445.         dptr[3] = sptr[3] * val;
  446.         dptr[4] = sptr[4] * val;
  447.         dptr[5] = sptr[5] * val;
  448.         dptr[6] = sptr[6] * val;
  449.         dptr[7] = sptr[7] * val;
  450.         dptr += 8;
  451.         sptr += 8;
  452.         n -= 8;
  453.     }
  454.     while (n--)
  455.         *dptr++ = (*sptr++) * val;
  456.     }
  457. }
  458.  
  459.  
  460. /**************************************************************************
  461.  *
  462.  * Function: impSDivRow
  463.  *
  464.  * Description: Performs scalar division on the specified source row. The
  465.  *    source row is divided by the specified constant and the result is
  466.  *    placed in the destination row. The source and destination rows
  467.  *    can be the same.
  468.  *
  469.  *    destination = source / value
  470.  *
  471.  * Parameters: 
  472.  *    dptr (O) - destination row
  473.  *    sptr (I) - source row
  474.  *    val (I) - value to divide into the source row
  475.  *    n (I) - number of pixels in row
  476.  *
  477.  * Return: none
  478.  *
  479.  **************************************************************************/
  480.  
  481. void impSDivRow(register short *dptr, register short *sptr,
  482.                 register int val, register int n)
  483. {
  484.     /*
  485.      * Sanity check the inputs
  486.      */
  487.     assert(dptr != NULL);
  488.     assert(sptr != NULL);
  489.     assert(val != 0);
  490.  
  491.     /*
  492.      * If dptr == sptr we can optimize the processing
  493.      */
  494.     if (sptr == dptr) {
  495.     while (n >= 8) {
  496.         dptr[0] /= val;
  497.         dptr[1] /= val;
  498.         dptr[2] /= val;
  499.         dptr[3] /= val;
  500.         dptr[4] /= val;
  501.         dptr[5] /= val;
  502.         dptr[6] /= val;
  503.         dptr[7] /= val;
  504.         dptr += 8;
  505.         n -= 8;
  506.     }
  507.     while (n--) {
  508.         *dptr = (*dptr) / val;
  509.         dptr++;
  510.     }
  511.     } else {
  512.     while (n >= 8) {
  513.         dptr[0] = sptr[0] / val;
  514.         dptr[1] = sptr[1] / val;
  515.         dptr[2] = sptr[2] / val;
  516.         dptr[3] = sptr[3] / val;
  517.         dptr[4] = sptr[4] / val;
  518.         dptr[5] = sptr[5] / val;
  519.         dptr[6] = sptr[6] / val;
  520.         dptr[7] = sptr[7] / val;
  521.         dptr += 8;
  522.         sptr += 8;
  523.         n -= 8;
  524.     }
  525.     while (n--)
  526.         *dptr++ = (*sptr++) / val;
  527.     }
  528. }
  529.  
  530.  
  531. /**************************************************************************
  532.  *
  533.  * Function: impClampRow
  534.  *
  535.  * Description: Clamps the value of the source row between the specified
  536.  *    lo and hi values inclusive. The result is placed in the destination
  537.  *    row. The source and destination rows can be the same.
  538.  *
  539.  * Parameters: 
  540.  *    dptr (O) - destination row
  541.  *    sptr (I) - source row
  542.  *    lov (I) - lo clamp value
  543.  *    hiv (I) - high clamp value
  544.  *    n (I) - number of pixels in row
  545.  *
  546.  * Return: none
  547.  *
  548.  **************************************************************************/
  549.  
  550. /* Clamping macro */
  551.  
  552. #define CLAMP_VAL(v,lov,hiv)    (((v) < (lov)) ? (lov): \
  553.                         (((v) > (hiv)) ? (hiv): (v)))
  554.  
  555. void impClampRow(register short *dptr, register short *sptr,
  556.             register int lov, register int hiv, register int n)
  557. {
  558.     /*
  559.      * Sanity check the inputs
  560.      */
  561.     assert(dptr != NULL);
  562.     assert(sptr != NULL);
  563.  
  564.     while (n >= 8) {
  565.     dptr[0] = (short)CLAMP_VAL(sptr[0], lov, hiv);
  566.     dptr[1] = (short)CLAMP_VAL(sptr[1], lov, hiv);
  567.     dptr[2] = (short)CLAMP_VAL(sptr[2], lov, hiv);
  568.     dptr[3] = (short)CLAMP_VAL(sptr[3], lov, hiv);
  569.     dptr[4] = (short)CLAMP_VAL(sptr[4], lov, hiv);
  570.     dptr[5] = (short)CLAMP_VAL(sptr[5], lov, hiv);
  571.     dptr[6] = (short)CLAMP_VAL(sptr[6], lov, hiv);
  572.     dptr[7] = (short)CLAMP_VAL(sptr[7], lov, hiv);
  573.     dptr += 8;
  574.     sptr += 8;
  575.     n -= 8;
  576.     }
  577.     while (n--) {
  578.     *dptr++ = (short)CLAMP_VAL(*sptr, lov, hiv);
  579.     sptr++;
  580.     }
  581. }
  582.